Il linguaggio di programmazione Rust: Dati grezzi a schemi definiti

Immagina i dati grezzi come un flusso non etichettato: un territorio selvaggio della memoria. In Rust, iniziamo gestendo i dati come blocchi contigui (fette e array). Questa transizione dai dati grezzi a schemi definiti segna lo spostamento dalla memoria anonima a strutture con uno scopo.

1. Il livello "grezzo"

Le fette e gli array rappresentano i dati nella loro forma più semplice. La sicurezza è mantenuta tramite verifiche di proprietà al momento del compilatore piuttosto che un sovraccarico in fase di esecuzione. Usando il prestito (&) ci permette di creare "visualizzazioni" dei dati senza spostare i valori.

2. Limiti semantici

Mentre le funzioni come first_word sono flessibili (accettando Stringa, &str, o letterali), raggiungono un limite semantico. Il compilatore sa che la memoria è sicura, ma non sa cosa rappresentino i dati rappresentano (ad esempio, un nome utente rispetto a un valore da sensore) fino a quando non li mappiamo a un Struct.

Principio architettonico: I concetti di proprietà, prestito e fette garantiscono la sicurezza della memoria nei programmi Rust al momento della compilazione, eliminando la necessità di un garbage collector.

TERMINALbash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

What is the main benefit of using a string slice (&str) over a String in a function signature?

It takes ownership of the data to prevent leaks.

It allows the function to accept both Strings and string literals via deref coercion.

It automatically converts the text to uppercase.

It stores the data on the stack instead of the heap.

QUESTION 2

In the expression 'let slice = &a[1..3]', what indices of array 'a' are included?

1, 2, and 3

1 and 2

2 and 3

Only index 1

QUESTION 3

Why do we say raw slices lack 'domain clarity'?

They are technically unsafe to use in production.

They don't provide metadata about what the data represents in the business logic.

They cannot be used with integers.

They are limited to 256 bytes of data.

QUESTION 4

Does a slice (&[i32]) own the data it points to?

Yes, it takes ownership of the range.

No, it is a reference to a portion of data owned by another variable.

Only if the array is mutable.

Yes, but only at compile time.

QUESTION 5

When does Rust check for slice out-of-bounds errors?

Exclusively at compile time.

Exclusively at runtime.

Compile time for fixed ranges; runtime for dynamic indices.

Rust does not check for bounds errors.